#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include <iostream>
#include <string>
#include <functional>
#include <pthread.h>
#include <unistd.h>
using namespace std;

//版本2：模板类
// namespace ThreadModule
// {
    
//     static int num=1;//常变量，不能加const，不然不能修改了
//     enum class STATUS    //线程的三种状态
//     {
//         NEW,
//         RUNNING,
//         STOP
//     };

//     template <class T>
//     class Thread
//     {
//     private:
//         using func_t=std::function<void(T)>;//********重点******** func_t函数得放在类内，这样保证模板类的T是一样的。设置一个函数类型 =》 func_t
//         static void* routine(void* args)
//         {
//             Thread<T>* td=static_cast<Thread<T>*>(args);//类型转化为Thread*
//             td->_func();//将this指针传递参数，再在类内通过this指针执行对应的_func方法
//             return 0;
//         }

//     public:
//         Thread(func_t func,T data):_func(func),_data(data),_status(STATUS::NEW)   //构造函数，参数：函数方法传递进来
//         {
//             _name="thread "+std::to_string(num++);//线程名从1开始，1、2、3、4...
//         }
//         bool start()//线程独立start 但线程结束了不代表Thread对象就结束了=>可以设置线程状态enum
//         {
//             //若线程不是START状态就需要start
//             if(_status!=STATUS::RUNNING)
//             {
//                 int n=::pthread_create(&_tid,nullptr,routine,this);//创建线程
//                 if(n!=0)
//                     return false;
//                 else
//                 {
                    
//                     _status=STATUS::RUNNING;
//                     return true;
//                 }
//             }

//             return true;
//         }

//         bool stop()
//         {
//             if(_status==STATUS::RUNNING)
//             {
//                 int n=::pthread_cancel(_tid);//创建线程
//                 if(n!=0)
//                     return false;
//                 else
//                 {
                    
//                     _status=STATUS::RUNNING;
//                     return true;
//                 }
//             }
//             return true;
//         }

//         bool join()
//         {
//             if(_joinable)
//             {
//                 int n=::pthread_join(_tid,nullptr);
//                 if(n!=0)
//                     return false;
//                 else
//                 {
//                     _status=STATUS::STOP;
//                     return true;
//                 }
                    
                
//             }
//             return true;
//         }
//         std::string Name()
//         {
//             return _name;
//         }

//         void Detach()
//         {
//             _joinable=false;
//             ::pthread_detach(_tid);
//         }

//         void EnableJoinable()
//         {
//             _joinable=false;
//         }
//         ~Thread()
//         {}

//     private:
//         std::string _name;
//         pthread_t _tid;//线程id
//         pid_t _pid;//对应进程id
//         bool _joinable;//是否等待
//         func_t _func;//线程执行的函数方法
//         STATUS _status;
//         T _data;//传入数据,存储数据
//     };

// }



//版本1
namespace ThreadModule
{
    using func_t=std::function<void()>;//设置一个函数类型 =》 func_t
    static int num=1;//常变量，不能加const，不然不能修改了
    enum class STATUS    //线程的三种状态
    {
        NEW,
        RUNNING,
        STOP
    };

    class Thread
    {
    private:
        static void* routine(void* args)
        {
            Thread* td=static_cast<Thread*>(args);//类型转化为Thread*
            td->_func();//将this指针传递参数，再在类内通过this指针执行对应的_func方法
            return 0;
        }

    public:
        Thread(func_t func):_func(func),_status(STATUS::NEW)   //构造函数，参数：函数方法传递进来
        {
            _name="thread "+std::to_string(num++);//线程名从1开始，1、2、3、4...
        }
        bool start()//线程独立start 但线程结束了不代表Thread对象就结束了=>可以设置线程状态enum
        {
            //若线程不是START状态就需要start
            if(_status!=STATUS::RUNNING)
            {
                int n=::pthread_create(&_tid,nullptr,routine,this);//创建线程
                if(n!=0)
                    return false;
                else
                {
                    
                    _status=STATUS::RUNNING;
                    return true;
                }
            }

            return true;
        }

        bool stop()
        {
            if(_status==STATUS::RUNNING)
            {
                int n=::pthread_cancel(_tid);//创建线程
                if(n!=0)
                    return false;
                else
                {
                    
                    _status=STATUS::RUNNING;
                    return true;
                }
            }
            return true;
        }

        bool join()
        {
            if(_joinable)
            {
                int n=::pthread_join(_tid,nullptr);
                if(n!=0)
                    return false;
                else
                {
                    _status=STATUS::STOP;
                    return true;
                }
                    
                
            }
            return true;
        }
        std::string Name()
        {
            return _name;
        }

        void Detach()
        {
            _joinable=false;
            ::pthread_detach(_tid);
        }

        void EnableJoinable()
        {
            _joinable=false;
        }
        ~Thread()
        {}

    private:
        std::string _name;
        pthread_t _tid;//线程id
        pid_t _pid;//对应进程id
        bool _joinable;//是否等待
        func_t _func;//线程执行的函数方法
        STATUS _status;
    };




}








#endif



